package org.platform.mo.db;

import javax.persistence.Column;
import javax.persistence.Id;
import javax.persistence.Table;

@Table(name = "tb_fd_testresults_ber")
public class FdTestResultsBer {
    /**
     * ID
     */
    @Id
    @Column(name = "ID")
    private String id;

    /**
     * 诊断ID
     */
    @Column(name = "DiagnoseID")
    private String diagnoseid;

    /**
     * 通道ID
     */
    @Column(name = "ChannelID")
    private Integer channelid;

    /**
     * 测试子项序号(格式：XXX，从1开始编号，不足三位补零)
     */
    @Column(name = "TestSubID")
    private String testsubid;

    /**
     * 结果
     */
    @Column(name = "Result")
    private Integer result;

    /**
     * 站点
     */
    @Column(name = "Station")
    private String station;

    /**
     * 误差原因
     */
    @Column(name = "ErrorReason")
    private String errorreason;

    /**
     * 测试开始时间
     */
    @Column(name = "TestStartTime")
    private String teststarttime;

    /**
     * 测试结束时间
     */
    @Column(name = "TestEndTime")
    private String testendtime;

    /**
     * 调制模式
     */
    @Column(name = "ModulationMode")
    private Integer modulationmode;

    /**
     * 射频频率
     */
    @Column(name = "RFFrequency")
    private Integer rffrequency;

    /**
     * 中频频率
     */
    @Column(name = "IFFrequency")
    private Integer iffrequency;

    /**
     * 测量带宽
     */
    @Column(name = "MeasureBW")
    private Float measurebw;

    /**
     * 误码率
     */
    @Column(name = "BER")
    private Float ber;

    /**
     * 噪声功率
     */
    @Column(name = "NoisePower")
    private Float noisepower;

    /**
     * 信号功率
     */
    @Column(name = "SignalPower")
    private Float signalpower;

    /**
     * 理论EBN0
     */
    @Column(name = "TheoryEBN0")
    private Float theoryebn0;

    /**
     * 测量EBN0
     */
    @Column(name = "MeasureEBN0")
    private Float measureebn0;

    /**
     * 设备链路(
     * LNA=“设备编号”;
     * UC=“设备编号”;
     * DC=“设备编号”;
     * MOD=“设备编号”;
     * Demod=“设备编号”;
     * 设备编号之间采用“;”隔开
     * )
     */
    @Column(name = "DevLink")
    private String devlink;

    /**
     * I路维特比编码(0：Off
     * 1：G1+G2/
     * 2：G1+G2
     * 3：G2/+G1
     * 4：G2 +G1
     * )
     */
    @Column(name = "ViterbiDecoder_I")
    private Integer viterbidecoderI;

    /**
     * Q路维特比编码(0：Off
     * 1：G1+G2/
     * 2：G1+G2
     * 3：G2/+G1
     * 4：G2 +G1
     * )
     */
    @Column(name = "ViterbiDecoder_Q")
    private Integer viterbidecoderQ;

    /**
     * RS223编码(0：Enable：使能
     * 1：Disable：禁止
     * )
     */
    @Column(name = "RS223")
    private Integer rs223;

    /**
     * RS239编码(0：Enable：使能
     * 1：Disable：禁止
     * )
     */
    @Column(name = "RS239")
    private Integer rs239;

    /**
     * LDPC编码(0：Enable：使能
     * 1：Disable：禁止
     * )
     */
    @Column(name = "LDPC")
    private Integer ldpc;

    /**
     * 解调器 id
     */
    @Column(name = "DemodulatorId")
    private String demodulatorid;

    /**
     * 获取ID
     *
     * @return ID - ID
     */
    public String getId() {
        return id;
    }

    /**
     * 设置ID
     *
     * @param id ID
     */
    public void setId(String id) {
        this.id = id;
    }

    /**
     * 获取诊断ID
     *
     * @return DiagnoseID - 诊断ID
     */
    public String getDiagnoseid() {
        return diagnoseid;
    }

    /**
     * 设置诊断ID
     *
     * @param diagnoseid 诊断ID
     */
    public void setDiagnoseid(String diagnoseid) {
        this.diagnoseid = diagnoseid;
    }

    /**
     * 获取通道ID
     *
     * @return ChannelID - 通道ID
     */
    public Integer getChannelid() {
        return channelid;
    }

    /**
     * 设置通道ID
     *
     * @param channelid 通道ID
     */
    public void setChannelid(Integer channelid) {
        this.channelid = channelid;
    }

    /**
     * 获取测试子项序号(格式：XXX，从1开始编号，不足三位补零)
     *
     * @return TestSubID - 测试子项序号(格式：XXX，从1开始编号，不足三位补零)
     */
    public String getTestsubid() {
        return testsubid;
    }

    /**
     * 设置测试子项序号(格式：XXX，从1开始编号，不足三位补零)
     *
     * @param testsubid 测试子项序号(格式：XXX，从1开始编号，不足三位补零)
     */
    public void setTestsubid(String testsubid) {
        this.testsubid = testsubid;
    }

    /**
     * 获取结果
     *
     * @return Result - 结果
     */
    public Integer getResult() {
        return result;
    }

    /**
     * 设置结果
     *
     * @param result 结果
     */
    public void setResult(Integer result) {
        this.result = result;
    }

    /**
     * 获取站点
     *
     * @return Station - 站点
     */
    public String getStation() {
        return station;
    }

    /**
     * 设置站点
     *
     * @param station 站点
     */
    public void setStation(String station) {
        this.station = station;
    }

    /**
     * 获取误差原因
     *
     * @return ErrorReason - 误差原因
     */
    public String getErrorreason() {
        return errorreason;
    }

    /**
     * 设置误差原因
     *
     * @param errorreason 误差原因
     */
    public void setErrorreason(String errorreason) {
        this.errorreason = errorreason;
    }

    /**
     * 获取测试开始时间
     *
     * @return TestStartTime - 测试开始时间
     */
    public String getTeststarttime() {
        return teststarttime;
    }

    /**
     * 设置测试开始时间
     *
     * @param teststarttime 测试开始时间
     */
    public void setTeststarttime(String teststarttime) {
        this.teststarttime = teststarttime;
    }

    /**
     * 获取测试结束时间
     *
     * @return TestEndTime - 测试结束时间
     */
    public String getTestendtime() {
        return testendtime;
    }

    /**
     * 设置测试结束时间
     *
     * @param testendtime 测试结束时间
     */
    public void setTestendtime(String testendtime) {
        this.testendtime = testendtime;
    }

    /**
     * 获取调制模式
     *
     * @return ModulationMode - 调制模式
     */
    public Integer getModulationmode() {
        return modulationmode;
    }

    /**
     * 设置调制模式
     *
     * @param modulationmode 调制模式
     */
    public void setModulationmode(Integer modulationmode) {
        this.modulationmode = modulationmode;
    }

    /**
     * 获取射频频率
     *
     * @return RFFrequency - 射频频率
     */
    public Integer getRffrequency() {
        return rffrequency;
    }

    /**
     * 设置射频频率
     *
     * @param rffrequency 射频频率
     */
    public void setRffrequency(Integer rffrequency) {
        this.rffrequency = rffrequency;
    }

    /**
     * 获取中频频率
     *
     * @return IFFrequency - 中频频率
     */
    public Integer getIffrequency() {
        return iffrequency;
    }

    /**
     * 设置中频频率
     *
     * @param iffrequency 中频频率
     */
    public void setIffrequency(Integer iffrequency) {
        this.iffrequency = iffrequency;
    }

    /**
     * 获取测量带宽
     *
     * @return MeasureBW - 测量带宽
     */
    public Float getMeasurebw() {
        return measurebw;
    }

    /**
     * 设置测量带宽
     *
     * @param measurebw 测量带宽
     */
    public void setMeasurebw(Float measurebw) {
        this.measurebw = measurebw;
    }

    /**
     * 获取误码率
     *
     * @return BER - 误码率
     */
    public Float getBer() {
        return ber;
    }

    /**
     * 设置误码率
     *
     * @param ber 误码率
     */
    public void setBer(Float ber) {
        this.ber = ber;
    }

    /**
     * 获取噪声功率
     *
     * @return NoisePower - 噪声功率
     */
    public Float getNoisepower() {
        return noisepower;
    }

    /**
     * 设置噪声功率
     *
     * @param noisepower 噪声功率
     */
    public void setNoisepower(Float noisepower) {
        this.noisepower = noisepower;
    }

    /**
     * 获取信号功率
     *
     * @return SignalPower - 信号功率
     */
    public Float getSignalpower() {
        return signalpower;
    }

    /**
     * 设置信号功率
     *
     * @param signalpower 信号功率
     */
    public void setSignalpower(Float signalpower) {
        this.signalpower = signalpower;
    }

    /**
     * 获取理论EBN0
     *
     * @return TheoryEBN0 - 理论EBN0
     */
    public Float getTheoryebn0() {
        return theoryebn0;
    }

    /**
     * 设置理论EBN0
     *
     * @param theoryebn0 理论EBN0
     */
    public void setTheoryebn0(Float theoryebn0) {
        this.theoryebn0 = theoryebn0;
    }

    /**
     * 获取测量EBN0
     *
     * @return MeasureEBN0 - 测量EBN0
     */
    public Float getMeasureebn0() {
        return measureebn0;
    }

    /**
     * 设置测量EBN0
     *
     * @param measureebn0 测量EBN0
     */
    public void setMeasureebn0(Float measureebn0) {
        this.measureebn0 = measureebn0;
    }

    /**
     * 获取设备链路(
     * LNA=“设备编号”;
     * UC=“设备编号”;
     * DC=“设备编号”;
     * MOD=“设备编号”;
     * Demod=“设备编号”;
     * 设备编号之间采用“;”隔开
     * )
     *
     * @return DevLink - 设备链路(
     * LNA=“设备编号”;
     * UC=“设备编号”;
     * DC=“设备编号”;
     * MOD=“设备编号”;
     * Demod=“设备编号”;
     * 设备编号之间采用“;”隔开
     * )
     */
    public String getDevlink() {
        return devlink;
    }

    /**
     * 设置设备链路(
     * LNA=“设备编号”;
     * UC=“设备编号”;
     * DC=“设备编号”;
     * MOD=“设备编号”;
     * Demod=“设备编号”;
     * 设备编号之间采用“;”隔开
     * )
     *
     * @param devlink 设备链路(
     *                LNA=“设备编号”;
     *                UC=“设备编号”;
     *                DC=“设备编号”;
     *                MOD=“设备编号”;
     *                Demod=“设备编号”;
     *                设备编号之间采用“;”隔开
     *                )
     */
    public void setDevlink(String devlink) {
        this.devlink = devlink;
    }

    /**
     * 获取I路维特比编码(0：Off
     * 1：G1+G2/
     * 2：G1+G2
     * 3：G2/+G1
     * 4：G2 +G1
     * )
     *
     * @return ViterbiDecoder_I - I路维特比编码(0：Off
     * 1：G1+G2/
     * 2：G1+G2
     * 3：G2/+G1
     * 4：G2 +G1
     * )
     */
    public Integer getViterbidecoderI() {
        return viterbidecoderI;
    }

    /**
     * 设置I路维特比编码(0：Off
     * 1：G1+G2/
     * 2：G1+G2
     * 3：G2/+G1
     * 4：G2 +G1
     * )
     *
     * @param viterbidecoderI I路维特比编码(0：Off
     *                        1：G1+G2/
     *                        2：G1+G2
     *                        3：G2/+G1
     *                        4：G2 +G1
     *                        )
     */
    public void setViterbidecoderI(Integer viterbidecoderI) {
        this.viterbidecoderI = viterbidecoderI;
    }

    /**
     * 获取Q路维特比编码(0：Off
     * 1：G1+G2/
     * 2：G1+G2
     * 3：G2/+G1
     * 4：G2 +G1
     * )
     *
     * @return ViterbiDecoder_Q - Q路维特比编码(0：Off
     * 1：G1+G2/
     * 2：G1+G2
     * 3：G2/+G1
     * 4：G2 +G1
     * )
     */
    public Integer getViterbidecoderQ() {
        return viterbidecoderQ;
    }

    /**
     * 设置Q路维特比编码(0：Off
     * 1：G1+G2/
     * 2：G1+G2
     * 3：G2/+G1
     * 4：G2 +G1
     * )
     *
     * @param viterbidecoderQ Q路维特比编码(0：Off
     *                        1：G1+G2/
     *                        2：G1+G2
     *                        3：G2/+G1
     *                        4：G2 +G1
     *                        )
     */
    public void setViterbidecoderQ(Integer viterbidecoderQ) {
        this.viterbidecoderQ = viterbidecoderQ;
    }

    /**
     * 获取RS223编码(0：Enable：使能
     * 1：Disable：禁止
     * )
     *
     * @return RS223 - RS223编码(0：Enable：使能
     * 1：Disable：禁止
     * )
     */
    public Integer getRs223() {
        return rs223;
    }

    /**
     * 设置RS223编码(0：Enable：使能
     * 1：Disable：禁止
     * )
     *
     * @param rs223 RS223编码(0：Enable：使能
     *              1：Disable：禁止
     *              )
     */
    public void setRs223(Integer rs223) {
        this.rs223 = rs223;
    }

    /**
     * 获取RS239编码(0：Enable：使能
     * 1：Disable：禁止
     * )
     *
     * @return RS239 - RS239编码(0：Enable：使能
     * 1：Disable：禁止
     * )
     */
    public Integer getRs239() {
        return rs239;
    }

    /**
     * 设置RS239编码(0：Enable：使能
     * 1：Disable：禁止
     * )
     *
     * @param rs239 RS239编码(0：Enable：使能
     *              1：Disable：禁止
     *              )
     */
    public void setRs239(Integer rs239) {
        this.rs239 = rs239;
    }

    /**
     * 获取LDPC编码(0：Enable：使能
     * 1：Disable：禁止
     * )
     *
     * @return LDPC - LDPC编码(0：Enable：使能
     * 1：Disable：禁止
     * )
     */
    public Integer getLdpc() {
        return ldpc;
    }

    /**
     * 设置LDPC编码(0：Enable：使能
     * 1：Disable：禁止
     * )
     *
     * @param ldpc LDPC编码(0：Enable：使能
     *             1：Disable：禁止
     *             )
     */
    public void setLdpc(Integer ldpc) {
        this.ldpc = ldpc;
    }

    /**
     * 获取解调器 id
     *
     * @return DemodulatorId - 解调器 id
     */
    public String getDemodulatorid() {
        return demodulatorid;
    }

    /**
     * 设置解调器 id
     *
     * @param demodulatorid 解调器 id
     */
    public void setDemodulatorid(String demodulatorid) {
        this.demodulatorid = demodulatorid;
    }
}